local 战斗单位 = class('战斗单位')
local function 排序(a, b) return a.cp > b.cp end
local ggf = require('GGE.函数')
local 阵法位置 = require("战斗逻辑/战斗位置")
function 战斗单位:初始化(当前)
	self.当前 = 当前
	self.伤害图片 = 多开数据[self.当前].__主控.战斗文字[1]
	self.回复图片 = 多开数据[self.当前].__主控.战斗文字[2]
	self.暴击图片 = 多开数据[self.当前].__主控.战斗文字[4]
	self.法术暴击图片 = 多开数据[self.当前].__主控.战斗文字[6]

end

function 战斗单位:添加特技内容(q)
	self.特技文本 = 分割字符(q)
	self.特技总数 = #self.特技文本
	self.特技序列 = {}
	self.特技次数 = 20
	self.特技间隔 = 4
	for n = 1, #self.特技文本 do
		self.特技序列[n] = {}
		self.特技序列[n].文本 = self.特技文本[n]
		self.特技序列[n].高度 = 0
		self.特技序列[n].x = self.显示xy.x - self.特技总数 * 4
		self.特技序列[n].y = self.显示xy.y
	end
	self.特技顺序 = 1
	self.特技内容开关 = true
	self.关闭计次 = 0
end

function 战斗单位:创建单位(数据, 队伍id, 编号)
	self.编号 = 编号
	self.数据 = 数据
	self.动画 = __战斗动画(self.当前)
	self.动画:创建动画(数据.模型, 数据.类型, 数据.染色方案, 数据.染色组, 数据.变异, 数据.武器, 数据.变身数据, 数据.饰品, 数据.炫彩, 数据.炫彩组, 数据.锦衣,数据.副武器)
	self.动作 = "待战"
	self.名称 = 数据.名称
	self.门派 = 数据.门派
	self.单位id = 数据.id
	self.单位类型 = 数据.类型
	self.主动技能 = 数据.主动技能
	self.武器子类 = 数据.武器子类
	self.武器等级 = 数据.等级 or 数据.等级
	self.特技技能 = 数据.特技技能
	self.自动指令 = 数据.自动指令
	self.战意 = 数据.战意
	self.追加法术=数据.披坚执锐
	self.超级战意=数据.超级战意
	self.如意神通=数据.如意神通
	self.智能施法=数据.智能施法
	self.五行珠=数据.五行珠
	self.人参果=数据.人参果
	self.骤雨=数据.骤雨
	self.共生=数据.共生
	self.法宝=数据.法宝
	self.气血 = 数据.气血 or 数据.最大气血
	self.魔法 = 数据.魔法
	self.愤怒 = 数据.愤怒
	self.队伍 = 数据.队伍
	self.黎魂 = 数据.黎魂
	self.战鼓 = 数据.战鼓
	self.最大气血 = 数据.最大气血
	self.气血上限 = 数据.气血上限 
	self.丸子time = {开关 = true,时间=os.time() + 7}
	self.丸子进化 = 数据.丸子进化
	self.超级夜战 = 数据.超级夜战
	self.超反击伤害 = 数据.超反击伤害
	self.超级偷袭 = 数据.超级偷袭
	self.色相变身 = 0
	self.门派 = 数据.门派
	名字16:置颜色(95, 218, 102)
	self.名称精灵 = 名字16:取精灵(self.名称)
	self.名称py = math.floor(0 - self.名称精灵.宽度 / 2)
	local 位置
	if 数据.队伍 == 多开数据[self.当前].__战斗主控.队伍id then
		self.初始方向 = 3
		self.敌我 = 1
		self.逃跑方向 = 0
		位置 = 多开数据[self.当前].__战斗主控.我方位置
	else
		self.初始方向 = 0
		self.敌我 = 2
		self.逃跑方向 = 3
		位置 = 多开数据[self.当前].__战斗主控.敌方位置
	end
	if 数据.附加阵法~="普通" then
		if  self.敌我==1 then
			位置=多开数据[self.当前].__战斗主控.阵型位置[数据.附加阵法].我方
		else
			位置=多开数据[self.当前].__战斗主控.阵型位置[数据.附加阵法].敌方
		end
	end
	if self.敌我==1 and self.丸子进化 ~= nil and self.丸子time.开关 then
		self.丸子time.开关=false
		self:增加丸子入场(self.丸子进化)
	end
	-- if self.敌我==1 then
	-- 	self.护盾动画 = 
	-- else
	-- 	self.护盾动画 = 
	-- end
	self.浮空动画 = 多开数据[self.当前].__主控:载入特效("浮空")
    self.特殊浮空高度 = 0
    self.浮空高度 = 0
	self.方向 = self.初始方向
	self.动画:置方向(self.方向, self.动作)
	self.模型 = 数据.模型
	self.移动坐标 = {}
	self.移动上限 = 30
	self.单位消失 = false
	self.移动频率 = 40
	self.攻击特效 = {}
	self.法术特效 = {}
	self.状态特效 = {}
	self.掉血开关 = false
	self.伤害序列 = {}
	self.捕捉开关 = false
	self.是否显示 = true
	self.保护 = false
	self.友伤 = false
	self.护盾 = 0
	self.护盾开关 = false
	--self.武器宽度 = 0
	self.排序位置 = 数据.位置
	self.招式特效 = 数据.招式特效
	self.攻击帧, self.攻击延迟, self.终极帧 = 多开数据[self.当前].__主控:取攻击帧(self.模型, self.武器子类)
	self.高度 = self.动画.动画["待战"].高度
	if self.高度 > 120 then
		self.高度 = 120
	elseif self.高度 < 60 then
		self.高度 = 60
	elseif self.高度 < 85 then
		self.高度 = 85
	end
	if self.位置 == 2 then
		self.高度 = self.高度 + 20
	else
		self.高度 = self.高度 + 20
	end
	self.宽度 = self.动画.动画["待战"].宽度
	if 数据.武器 ~= nil and 数据.变身数据 == nil then

	else

	end
	self.移动补偿 = { [0] = 10, [1] = 10 }
	if self.移动补偿[0] < 30 then
		self.移动补偿[0] = 30
	elseif self.移动补偿[1] < 30 then
		self.移动补偿[1] = 30
	elseif self.移动补偿[0] > 100 then
		self.移动补偿[0] = 100
	elseif self.移动补偿[1] > 100 then
		self.移动补偿[1] = 100
	end
	self.显示xy = require("GGE.坐标")(位置[数据.位置].x, 位置[数据.位置].y)
	if self.敌我 == 1 then
		local C补差X, C补差Y = 0, 0
		local R补差X, R补差Y = 0, 0
		C补差X, C补差Y = -155 + (__引擎宽高2(1) - 400), -2 + (__引擎宽高2(2) - 300)
		R补差X, R补差Y = -180 + (__引擎宽高2(1) - 400), -25 + (__引擎宽高2(2) - 300)
		if 数据.位置 <= 5 then --角色
			self.显示xy.x, self.显示xy.y = self.显示xy.x + R补差X, self.显示xy.y + R补差Y
		else --前排 宠物
			self.显示xy.x, self.显示xy.y = self.显示xy.x + C补差X, self.显示xy.y + C补差Y
		end
		self.躲避参数 = 8
		self.躲避坐标 = 2
		self.反震误差 = { x = 50, y = 10 }
		self.逃跑坐标 = 3
	else
		local C补差X, C补差Y = 0, 0
		local R补差X, R补差Y = 0, 0
		C补差X, C补差Y = -75 + (__引擎宽高2(1) - 400), 12 + (__引擎宽高2(2) - 300)
		R补差X, R补差Y = -85 + (__引擎宽高2(1) - 400), 2 + (__引擎宽高2(2) - 300)
		if 数据.位置 <= 5 then --前排 宠物
			self.显示xy.x, self.显示xy.y = self.显示xy.x + R补差X, self.显示xy.y + R补差Y
		else --前排 宠物
			self.显示xy.x, self.显示xy.y = self.显示xy.x + C补差X, self.显示xy.y + C补差Y
		end
		self.反震误差 = { x = -50, y = -10 }
		self.躲避坐标 = -2
		self.躲避参数 = -8
		self.逃跑坐标 = -3
	end

	self.显示xy:floor()
	self.初始xy = require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
	self.飞镖开关 = false
	self.弓弩开关 = false
	self.攻击次数 = 0
	self.抖动数据 = { 开关 = false, 进程 = 0, x = 0, y = 0 }
	self.显示表 = {}
	self.血条栏 = __res:取精灵(__res:取地址('shape/ui/zd/', 0x4FD9FFF3))
	self.血条上限栏 = __res:取精灵(__res:取地址('shape/ui/zd/', 0x4FD9FFF3)):置颜色(__取颜色("浅黑"))
	self.战意特效 = {}
	self.血条栏:置区域(0, 0, math.floor(self.气血 / self.最大气血 * 36), 4)
	self:增加奇经八脉()
end

function 战斗单位:更改模型(模型, 类型)
	self.动画:创建动画(模型, 类型, nil, nil, false)
	self.模型 = 模型
	self.攻击帧, self.攻击延迟, self.终极帧 = 多开数据[self.当前].__主控:取攻击帧(self.模型, self.武器子类)
	self.高度 = self.动画.动画["待战"].高度
	if self.高度 == nil then
		self.高度 = 80
	end
	if self.高度 > 120 then
		self.高度 = 120
	elseif self.高度 < 60 then
		self.高度 = 60
	elseif self.高度 < 85 then
		self.高度 = 85
	end
	if self.位置 == 2 then
		self.高度 = self.高度 + 20
	else
		self.高度 = self.高度 + 20
	end

	self.宽度 = self.动画.动画["待战"].宽度
	self.动画:置方向(self.方向, self.动作)
end

function 战斗单位:更改人物模型(模型,类型,染色方案,染色组,变异,武器,变身数据)
	self.动画:创建动画(模型, 类型, 染色方案, 染色组, 变异,武器,变身数据)
	self.模型 = 模型
	self.攻击帧, self.攻击延迟, self.终极帧 = 多开数据[self.当前].__主控:取攻击帧(self.模型, self.武器子类)
	self.高度 = self.动画.动画["待战"].高度
	if self.高度 == nil then
		self.高度 = 80
	end
	if self.高度 > 120 then
		self.高度 = 120
	elseif self.高度 < 60 then
		self.高度 = 60
	elseif self.高度 < 85 then
		self.高度 = 85
	end
	if self.位置 == 2 then
		self.高度 = self.高度 + 20
	else
		self.高度 = self.高度 + 20
	end
	self.宽度 = self.动画.动画["待战"].宽度
	self.动画:置方向(self.方向, self.动作)
end

function 战斗单位:重置丸子技能(数据)
	self.丸子特效 = nil
	self.丸子time = {开关 = true,时间=os.time() + 3}
	self.丸子进化 = 数据.丸子进化
	self.超反击伤害 = 数据.超反击伤害
	self:增加丸子入场(self.丸子进化)
end

function 战斗单位:增加丸子入场(名称)
	if 名称 then
		local qtb = 取技能信息(名称)
		if qtb[7] ~= nil then
			self.丸子特效=__res:取图像(__res:取地址("shape/jn/", qtb[8])):到精灵()
			self.丸子特效:置颜色(255,105,180,255)
		end
	end
end

function 战斗单位:状态是否显示(i)
	local display = true
	if i == "战意1" and self.战意 ~= 1 then
		display = false
	elseif i == "战意2" and self.战意 ~= 2 then
		display = false
	elseif i == "战意3" and self.战意 and self.战意 < 3 then
		display = false
	elseif i == "超级战意1" and self.超级战意 ~= 1 then
		display = false
	elseif i == "超级战意2" and self.超级战意 ~= 2 then
		display = false
	elseif i == "超级战意3" and self.超级战意 and self.超级战意 < 3 then
		display = false
	elseif i == "人参娃娃1" and self.人参娃娃 and self.人参娃娃.层数 and (self.人参娃娃.层数 ~= 1 or self.人参娃娃.回合 <= 0) then
		display = false
	elseif i == "人参娃娃2" and self.人参娃娃 and self.人参娃娃.层数 and (self.人参娃娃.层数 ~= 2 or self.人参娃娃.回合 <= 0) then
		display = false
	elseif i == "人参娃娃3" and self.人参娃娃 and self.人参娃娃.层数 and (self.人参娃娃.层数 < 3 or self.人参娃娃.回合 <= 0) then
		display = false
	elseif i == "风灵" and (self.风灵 == nil or self.风灵 <= 0) then
		display = false
	elseif i == "剑意"  and self.剑意 and self.剑意 <= 0 then
		display = false
	elseif i == "符咒1"  and self.符咒 and self.符咒 ~= 1 then
		display = false
	elseif i == "符咒2"  and self.符咒 and self.符咒 ~= 2 then
		display = false
	elseif i == "符咒3"  and self.符咒 and self.符咒 ~= 3 then
		display = false
	elseif i == "符咒4"  and self.符咒 and self.符咒 ~= 4 then
		display = false
	elseif i == "符咒5"  and self.符咒 and self.符咒 < 5 then
		display = false
	elseif i == "雷法崩裂" and self.雷法崩裂 and self.雷法崩裂 <= 0 then
		display = false
	elseif i == "雷法震煞" and self.雷法震煞 and self.雷法震煞 <= 0 then
		display = false
	elseif i == "雷法坤伏" and self.雷法坤伏 and self.雷法坤伏 <= 0 then
		display = false
	elseif i == "雷法翻天" and self.雷法翻天 and self.雷法翻天 <= 0 then
		display = false
	elseif i == "雷法倒海" and self.雷法倒海 and self.雷法倒海 <= 0 then
		display = false
	elseif i == "灵药红" and self.灵药红 and self.灵药红 <= 0 then
		display = false
	elseif i == "灵药蓝" and self.灵药蓝 and self.灵药蓝 <= 0 then
		display = false
	elseif i == "灵药黄" and self.灵药黄 and self.灵药黄 <= 0 then
		display = false
	elseif i == "五行珠金" and self.五行珠金 and self.五行珠金 <= 0 then
		display = false
	elseif i == "五行珠木" and self.五行珠木 and self.五行珠木 <= 0 then
		display = false
	elseif i == "五行珠水" and self.五行珠水 and self.五行珠水 <= 0 then
		display = false
	elseif i == "五行珠火" and self.五行珠火 and self.五行珠火 <= 0 then
		display = false
	elseif i == "五行珠土" and self.五行珠土 and self.五行珠土 <= 0 then
		display = false
	end
	return display
end

function 战斗单位:取txz(特效)
	if Fighttxz[特效] then
		return Fighttxz[特效]
	end
	if 特效 == "宠物_静" then
		local mt = 取模型(多开数据[当前 or self and self.当前].角色信息.宠物.模型)
		return __res:取动画2(__res:取地址('shape/mx/', mt[1]))
	elseif 特效 == "宠物_走" then
		local mt = 取模型(多开数据[当前 or self and self.当前].角色信息.宠物.模型)
		return __res:取动画2(__res:取地址('shape/mx/', mt[2]))
	else
		return 1.15
	end
end

function 战斗单位:状态前置(特效, 模型)
	if 特效 ~= nil then
		local cp = 1
		local py = { 0, 0 }
		if Fightztqz[特效] then
			cp = Fightztqz[特效].cp and 1 or 2
			py = Fightztqz[特效].py
		end
		if 模型 == "泡泡" or 模型 == "超级泡泡" then
			py[2] = py[2] + 30
		end
		return { cp = cp, py = py }
	end
end

function 战斗单位:法术前置(特效, 模型)
	if 特效 ~= nil then
		local lssj = 特效库(特效)
		local cp = 1
		local py = { 0, 0 }
		if lssj[4] ~= nil then
			-- cp = lssj[4]
			py = { lssj[5], lssj[6] }
			if lssj[6] == 1 then
				py[2] = -self.高度
			elseif lssj[6] == 2 then
				py[2] = math.floor(-self.高度 / 2)
			elseif lssj[6] == 3 then
				py[2] = math.floor(-self.高度 / 3)
			elseif lssj[6] == -1 then
				py[2] = self.高度
			elseif lssj[6] == -2 then
				py[2] = math.floor(self.高度 / 2)
			elseif lssj[6] == -3 then
				py[2] = math.floor(self.高度 / 3)
			end
		end
		-- if cp then
		-- 	cp = 1
		-- else
		-- 	cp = 2
		-- end
		if 模型 == "泡泡" or 模型 == "超级泡泡" then
			py[2] = py[2] + 30
		end
		return cp, py
	end
end

function 战斗单位:无需物理特效(效果)
	if skill无需物理[效果] then
	    return true
	end
	return false
end

function 战斗单位:添加攻击特效(名称, 加速)
	local 名称1 = 名称
	if not self:无需物理特效(名称) then
		local txz = self:取txz(名称)
		-- if 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方] ~= nil and  多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方] .招式特效 ~= nil and  多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方] .招式特效[名称]~= nil and 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方] .招式特效[名称] == true  then
		-- 	local lssj = 特效库("新_"..名称)
		-- 	if lssj[1] ~= nil and lssj[2] ~= nil then
		-- 		名称1 = "新_"..名称1
		-- 	end
		-- end
		self.攻击特效[#self.攻击特效 + 1] = 多开数据[self.当前].__主控:载入特效(名称1, txz)
		self.攻击特效[#self.攻击特效].cp, self.攻击特效[#self.攻击特效].py = self:法术前置(名称, self.模型)
		self.攻击特效[#self.攻击特效]:置提速(txz)
		self.攻击特效[#self.攻击特效].当前帧 = 0
		self.攻击特效[#self.攻击特效].加速更新 = nil
		self.攻击特效[#self.攻击特效].加速更新 = 加速
	end
end

function 战斗单位:无需法术特效(效果)
	if skill无需法术[效果] then
	    return true
	end
	return false
end

function 战斗单位:添加法术特效(名称, 加速)
	local 名称1 = 名称
	if 名称1 == "干将莫邪" or 名称1 == "混元伞" or 名称1 == "断穹巨剑"
		or 名称1 == "风舞心经" or 名称1 == "赤焰" then
		if self.敌我 == 1 then
			名称1 = 名称1 .. "_我方"
		else
			名称1 = 名称1 .. "_敌方"
		end
	end
	if not self:无需法术特效(名称) then
		local txz = self:取txz(名称)
		if 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方] ~= nil and 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方].招式特效 ~= nil and 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方].招式特效[名称] ~= nil and 多开数据[self.当前].__战斗主控.战斗单位[多开数据[self.当前].__战斗主控.战斗流程[1].攻击方].招式特效[名称] == true then
			local lssj = 特效库("新_" .. 名称)
			if lssj[1] ~= nil and lssj[2] ~= nil then
				名称1 = "新_" .. 名称1
				txz = 1.5
			end
		end

		self.法术特效[#self.法术特效 + 1] = 多开数据[self.当前].__主控:载入特效(名称1, txz)
		self.法术特效[#self.法术特效]:置提速(txz)
		self.法术特效[#self.法术特效].cp, self.法术特效[#self.法术特效].py = self:法术前置(名称)
		if 名称 == "生命之泉" then
			self.法术特效[#self.法术特效].py[2] = self.法术特效[#self.法术特效].py[2] - 75
		elseif 名称 == "龙腾" then
			self.法术特效[#self.法术特效].加速 = 0.04
		elseif 名称 == "巨岩破" then
			self.法术特效[#self.法术特效].py[2] = self.法术特效[#self.法术特效].py[2] + 75
			self.法术特效[#self.法术特效].结束时间 = 40
		end
	else
		多开数据[self.当前].__战斗主控.掉血流程 = nil
	end
end

function 战斗单位:无需状态(效果)
	if skill无需状态[效果] then
	    return true
	end
	return false
end

function 战斗单位:增加状态(名称)
	if 名称 ~= nil then
		local 名称1 = 名称
		if Fightdiwo[名称1] then
			if self.敌我 == 1 then
				名称1 = 名称1 .. "_我方"
			else
				名称1 = 名称1 .. "_敌方"
			end
		end
		self.状态特效[名称] = self:状态前置(名称1, self.模型)
		local qtb = 取技能信息(名称)
		if qtb[1] ~= nil and qtb[6] ~= nil and qtb[7] ~= nil then
			self.状态特效[名称].小图标 = __res:取精灵(__res:取地址('shape/jn/', qtb[8]))
			self.状态特效[名称].介绍 = qtb[1]
		else
			self.状态特效[名称].小图标 = __res:取精灵(__res:取地址('shape/jn/', 3143201775))
			self.状态特效[名称].介绍 = 名称 .. "这个技能暂时没有添加提示请截图给管理员"
		end
		if not self:透明状态("状态_" .. 名称1) and not self:无需状态(名称1) and 特效库("状态_" .. 名称1) then
			self.状态特效[名称].动画 = 多开数据[self.当前].__主控:载入特效("状态_" .. 名称1, self:取txz(名称)):置循环(true)
			if type(self.状态特效[名称].动画) == "table" and self.状态特效[名称].动画[1] and self.状态特效[名称].动画[2] then
				self.状态特效[名称].动画[1].cp, self.状态特效[名称].动画[1].py = self.状态特效[名称].cp, self.状态特效[名称].py
				self.状态特效[名称].动画[2].cp, self.状态特效[名称].动画[1].py = self.状态特效[名称].cp, self.状态特效[名称].py
			else
				self.状态特效[名称].动画.cp, self.状态特效[名称].动画.py = self.状态特效[名称].cp, self.状态特效[名称].py
			end
		end
	end
end

function 战斗单位:加载特效(名称)
	local txz = self:取txz(名称)
	local 名称1 = 名称
	local cp = 多开数据[self.当前].__主控:载入特效(名称1, txz, 不显示)
	cp:置提速(txz)
	return cp
end

function 战斗单位:透明状态(效果)
	local xxg = false
	if 效果 == "状态_金刚护法" then
		xxg = true
	end
	return xxg
end

function 战斗单位:增加奇经八脉()
	if self.门派 == "凌波城" then
		self:增加状态("战意1")
		self:增加状态("战意2")
		self:增加状态("战意3")
		if self.经脉流派 == "灵霄斗士" then
			self:增加状态("超级战意1")
			self:增加状态("超级战意2")
			self:增加状态("超级战意3")
		end
	elseif self.门派 == "神木林" then
		if self.经脉流派 == "灵木药宗" then
			self:增加状态("灵药红")
			self:增加状态("灵药蓝")
			self:增加状态("灵药黄")
		else
			self:增加状态("风灵")
		end
	elseif self.门派 == "方寸山" and self.经脉流派 == "五雷正宗" then
		self:增加状态("符咒1")
		self:增加状态("符咒2")
		self:增加状态("符咒3")
		self:增加状态("符咒4")
		self:增加状态("符咒5")
		self:增加状态("雷法崩裂")
		self:增加状态("雷法震煞")
		self:增加状态("雷法坤伏")
		self:增加状态("雷法翻天")
		self:增加状态("雷法倒海")
	elseif self.门派 == "普陀山" and self.经脉流派 == "落伽神女" then
		self:增加状态("五行珠金")
		self:增加状态("五行珠木")
		self:增加状态("五行珠水")
		self:增加状态("五行珠火")
		self:增加状态("五行珠土")
	elseif self.门派 == "五庄观" and self.经脉流派 == "万寿真仙" then
		self:增加状态("人参娃娃1")
		self:增加状态("人参娃娃2")
		self:增加状态("人参娃娃3")
	elseif self.门派 == "大唐官府" and self.经脉流派 == "无双战神" then
		self:增加状态("剑意")
	end
end

function 战斗单位:更新奇经八脉(sj)
	for k, v in pairs(self.奇经八脉) do
		self.奇经八脉[k].层数 = sj[k]
	end
end

function 战斗单位:取移动坐标(类型, 攻击编号)
	if 类型 == "挨打" then
		if self.敌我 == 1 then
			return require("GGE.坐标")(self.初始xy.x, self.初始xy.y)
		else
			return require("GGE.坐标")(self.初始xy.x, self.初始xy.y)
		end
	elseif 类型 == "保护" then
		return require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
	elseif 类型 == "友伤" then
		return require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
	elseif 类型 == "返回" then
		return require("GGE.坐标")(self.初始xy.x, self.初始xy.y)
	end
end

function 战斗单位:回合结束重置()
	self.攻击次数 = 0
	if self.初始方向 ~= self.方向 then
		self.方向 = self.初始方向
		self.动画:置方向(self.初始方向, self.动作)
	end
end

function 战斗单位:换动作(动作, 复原)
	if 动作 == "攻击" then
		self.攻击次数 = self.攻击次数 + 1
		if self.攻击次数 == 2 then
			动作 = "攻击2"
			self.攻击次数 = 0
		end
	end
	self.动作 = 动作
	self.动画:置方向(self.偷袭方向 or self.方向, self.动作)
	self.动作复原 = 复原
	self.更新次数 = 0
	local 临时模型 = self.数据.模型
	if self.数据.类型 == "角色" or self.数据.类型 == "系统角色" then
		if self.数据.武器 ~= nil then
			if self.数据.武器.名称 == "龙鸣寒水" or self.数据.武器.名称 == "非攻" then
				local wq = "弓弩1"
				临时模型 = 临时模型 .. "_" .. wq
			else
				local wq = 多开数据[self.当前].__主控:取武器子类(self.数据.武器.子类)
				临时模型 = 临时模型 .. "_" .. wq
			end
		end
	end
	local 临时音乐 = 取音效(临时模型)
	if 临时音乐.攻击 ~= nil then
		临时音乐.攻击2 = 临时音乐.攻击
	end
	if 临时音乐 ~= nil and 临时音乐[动作] ~= nil and self.当前 == 多开数据.当前 then
		多开数据[self.当前].__主控:播放动作音乐(临时音乐.资源, 临时音乐[动作])
	end
	if 动作=="待战" and self.敌我 == 2 then
		self.显示xy=DeepCopy(self.初始xy)
	end
end

function 战斗单位:换方向(方向)
	self.动画:置方向(方向, self.动作)
end

function 战斗单位:取当前帧()
	return self.动画:取当前帧(self.动作)
end

function 战斗单位:取结束帧()
	return self.动画:取结束帧(self.动作)
end

function 战斗单位:取开始帧()
	return self.动画:取开始帧(self.动作)
end

function 战斗单位:取间隔()
	return self.动画.动画[self.动作]:取当前帧()
end

function 战斗单位:取中间()
	return self.动画.动画[self.动作]:取帧数() / 2
end

function 战斗单位:取状态()
	if self.移动开关 or self.击退开关 or self.击飞开关 or self.倒地开关 or self.返回开关 or self.躲避开关 or self.飞镖开关 or self.弓弩开关 or self.掉血开关 then
		return false
	else
		return true
	end
end

function 战斗单位:取施法完毕()
	if self.动作 == "施法" then
		if self:取当前帧() >= math.floor(self:取结束帧() * 0.8) then
			return true
		else
			return false
		end
	else
		return true
	end
end

function 战斗单位:设置飞镖(xy, 方向, 伤害, 死亡, 名称)
	self.飞镖动画 = 多开数据[self.当前].__主控:载入特效(名称, self:取txz(名称))
	self.飞镖xy = require("GGE.坐标")(xy.x, xy.y)
	self.飞镖xy.伤害 = 伤害
	self.飞镖xy.死亡 = 死亡
	self.飞镖动画:置方向(direction8(self.飞镖xy:取角度(self.显示xy.x, self.显示xy.y)))
	self.飞镖开关 = true
end

function 战斗单位:设置弓弩(xy, 方向, 名称)
	self.弓弩动画 = 多开数据[self.当前].__主控:载入特效(名称, self:取txz(名称))

	self.弓弩xy = require("GGE.坐标")(xy.x, xy.y)
	local 方向 = direction8(self.弓弩xy:取角度(self.显示xy.x, self.显示xy.y))
	-- print(方向1,方向)
	self.弓弩动画:置方向(方向)
	self.弓弩开关 = true
end

function 战斗单位:开启击退(死亡)
	self.击退开关 = true
	self.击退延迟 = true
	self.偏移类型 = 1
	self.停止偏移 = 30
	self.死亡参数 = 死亡
	self.击退坐标 = require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
	if self.敌我 == 2 then
		self.偏移坐标 = -1
		if self.死亡参数 ~= 0 then
			self.偏移坐标 = -1
		end
	else
		self.偏移坐标 = 1
		if self.死亡参数 ~= 0 then
			self.偏移坐标 = 1
		end
	end
end

function 战斗单位:击退处理()
	if self.偏移类型 == 1 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x + self.偏移坐标, self.显示xy.y + self.偏移坐标
		if self.显示xy:取距离(self.击退坐标) > self.停止偏移 then
			self.偏移类型 = 2
			if self.死亡参数 == 1 then
				self:死亡处理()
				self.显示xy.x, self.显示xy.y = self.击退坐标.x, self.击退坐标.y
				self.偏移类型 = 0
				self.击退开关 = false
				self.偏移类型 = 0
			else
				-- self.动作="待战"
				--self:换动作(self.动作,nil,nil)
				if self.敌我 == 2 then
					self.偏移坐标 = -1
					if self.死亡参数 ~= 0 then
						self.偏移坐标 = -2
					end
				else
					self.偏移坐标 = 1
					if self.死亡参数 ~= 0 then
						self.偏移坐标 = 2
					end
				end
				self.偏移类型 = 2
			end
		end
	elseif self.偏移类型 == 2 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x - self.偏移坐标, self.显示xy.y - self.偏移坐标
		if self.显示xy:取距离(self.击退坐标) <= 10 then
			self.偏移类型 = 0
			self.击退开关 = false
			self.动画.按帧更新 = false
			self.显示xy.x, self.显示xy.y = self.击退坐标.x, self.击退坐标.y
			if self.死亡参数 == 2 then
				self:死亡处理()
			else
				self.动作 = "待战"
				self:换动作(self.动作, nil, nil)
				self.动画:置方向(self.方向, self.动作)
			end
		end
	end
end

function 战斗单位:死亡处理1(死亡)
	self.死亡参数 = 死亡
	self:死亡处理()
end

function 战斗单位:死亡处理()
	--self.动画:置帧率(self.动作,0.1)
	self.死亡开关 = true
	if self.死亡参数 == 1 then
		self.击飞开关 = true
		self.击飞数据 = {}
		self.击飞流程 = 0
		self.击飞方向 = 0
		self.击飞开关 = true
		self.击飞流程 = 1
		self.击飞时间 = 取游戏时间()
		-- self.动画.按帧更新=true
		if self.敌我 == 2 then
			self.击飞数据[1] = { x = 20, y = 43, 终止 = 引擎.高度 }
			self.击飞数据[2] = { x = 20, y = 41, 终止 = 引擎.宽度 }
		else
			self.击飞数据[1] = { x = -20, y = -43, 终止 = 引擎.高度 }
			self.击飞数据[2] = { x = -20, y = -41, 终止 = 引擎.宽度 }
		end
	elseif self.死亡参数 == 2 then
		self.动作 = "死亡"
		--self:播放音效("倒地")
		self:换方向(self.方向)
		self.倒地开关 = true
	end
end

function 战斗单位:倒地处理()
	--print(self.动作,self.动画:取当前帧(self.动作),self.动画:取开始帧(self.动作),self.动画:取结束帧(self.动作))
	if self.动画:取当前帧(self.动作) == self.动画:取结束帧(self.动作) then
		self.动作 = "死亡"
		self.倒地开关 = false
	end
end

function 战斗单位:击飞处理()
	if self.击飞流程 == 1 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x - self.击飞数据[self.击飞流程].x, self.显示xy.y - self.击飞数据[self.击飞流程].y
		if 取游戏时间() - self.击飞时间 >= 0.005 then
			self.方向 = self.方向 - 1
			if self.方向 < 0 then self.方向 = 3 end
			-- print(self.方向)
			self.击飞时间 = 取游戏时间()
			self:换方向(self.方向)
		end
		if self.显示xy:取距离(self.初始xy) > 引擎.高度 then
			self.击飞流程 = 2
		end
	elseif self.击飞流程 == 2 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x + self.击飞数据[self.击飞流程].x, self.显示xy.y + self.击飞数据[self.击飞流程].y
		if 取游戏时间() - self.击飞时间 >= 0.005 then
			self.方向 = self.方向 - 1
			if self.方向 < 0 then self.方向 = 3 end
			self.击飞时间 = 取游戏时间()
			self:换方向(self.方向)
		end
		if self.显示xy:取距离(self.初始xy) > 0 then
			self.击飞流程 = 0
			self.击飞开关 = false
		end
	end
end

function 战斗单位:返回事件()
	if self.移动坐标.x == nil  then
		self.移动坐标 = self:取移动坐标("返回")
	end
	if self.显示xy:取距离(self.移动坐标) >= 20 then
		self.移动距离 = self.显示xy:取移动坐标(20, self.移动坐标)
		self.角度 = self.显示xy:取角度(self.移动坐标.x, self.移动坐标.y)
		self.偷袭方向 = nil
		self:换方向(direction4(self.角度))
		if self.超级偷袭 then
			self.显示xy.x,self.显示xy.y=self.移动坐标.x,self.移动坐标.y
		else
			self.显示xy.x, self.显示xy.y = self.移动距离.x, self.移动距离.y
		end
	else
		self.返回开关 = false
		self.动作 = "待战"
		self:换方向(self.初始方向)
		self.显示xy.x, self.显示xy.y = self.初始xy.x, self.初始xy.y
	end
end

function 战斗单位:移动事件()
	if self.武器子类 ~= nil and self.武器子类 == 14 and not self.保护 then
		self.角度 = self.显示xy:取角度(self.移动坐标.x, self.移动坐标.y)
		self.方向 = direction4(self.角度)
		self.动画:置方向(direction4(self.角度), self.动作)
		self.移动开关 = false
		self.友伤 = false
		return
	end
	local 距离 = 0
	local 距离2 = 0
	if self.保护 then
		self.移动上限 = 30
	elseif self.友伤 then
		self.移动上限 = self.移动补偿[self.攻击次数]
	else
		self.移动上限 = 70
		if self.敌我 == 1 then
			距离2 = self.移动补偿[self.攻击次数]
			距离 = 30
		else
			距离2 = 0 - self.移动补偿[self.攻击次数]
			距离 = 0 - 30
		end
	end
	if self.显示xy:取距离(self.移动坐标.x + 距离2, self.移动坐标.y + 距离) > self.移动上限 then
		self.移动距离 = self.显示xy:取移动坐标(self.移动频率, self.移动坐标.x + 距离2, self.移动坐标.y + 距离)
		self.角度 = self.显示xy:取角度(self.移动坐标.x, self.移动坐标.y)
		self.方向 = direction4(self.角度)
		self.动画:置方向(direction4(self.角度), self.动作)
		if self.超级偷袭 then
			self.显示xy.x, self.显示xy.y = self.移动坐标.x, self.移动坐标.y
		else
			self.显示xy.x, self.显示xy.y = self.移动距离.x, self.移动距离.y
		end
	else
		self.角度 = self.显示xy:取角度(self.移动坐标.x, self.移动坐标.y)
		self.方向 = direction4(self.角度)
		self.动画:置方向(direction4(self.角度), self.动作)
		self.移动开关 = false
		self.移动坐标 = {}
		if self.保护 then
			self.移动上限 = 30
			self.保护 = false
		end
		if self.友伤 then
			self.移动上限 = 30
			self.友伤 = false
		end
	end
end

function 战斗单位:开启躲避()
	self.躲避类型 = 1
	self.停止躲避 = 75
	self.躲避开关 = true
	self.躲避数量 = 0
	self.躲避xy = require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
end

function 战斗单位:躲避事件()
	if self.躲避类型 == 1 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x + self.躲避坐标, self.显示xy.y + self.躲避坐标
		self.躲避数量 = math.floor(self.初始xy:取距离(self.显示xy) / 15)
		if self.初始xy:取距离(self.显示xy) >= self.停止躲避 then
			self.躲避类型 = 2
		end
	elseif self.躲避类型 == 2 then
		self.显示xy.x, self.显示xy.y = self.显示xy.x - self.躲避坐标, self.显示xy.y - self.躲避坐标
		self.躲避数量 = math.floor(self.初始xy:取距离(self.显示xy) / 15)
		if self.初始xy:取距离(self.显示xy) <= 5 then
			self.显示xy.x, self.显示xy.y = self.初始xy.x, self.初始xy.y
			self.躲避类型 = 0
			self.躲避开关 = false
			--self.掉血开关=false
		end
	end
end

function 战斗单位:设置溅射(xy, 方向, 伤害, 死亡)
	self.溅射数据 = { 伤害 = 伤害, 死亡 = 死亡 }
	self.溅射开关 = true
end

function 战斗单位:设置抓捕路径(目标, 成功)
	self:换动作("跑去")
	self.抓捕移动 = 目标
end

function 战斗单位:设置吸星大法路径(目标, 成功)
	self:换动作("待战")
	self.吸星大法移动=require("GGE.坐标")(300, 350)
end

function 战斗单位:吸星大法解除(目标)
	self:换动作("待战")
	self.吸星大法返回=self:取移动坐标("返回")
end

function 战斗单位:设置抓捕动画(目标, 模型, 成功, 名称)
	self.抓捕资源 = 取模型(模型)
	self.抓捕动画 = __res:取动画2(__res:取地址('shape/mx/', self.抓捕资源[2]))
	self.抓捕动画:置方向(3)
	self.抓捕流程 = 1
	self.抓捕成功 = 成功
	self.抓捕目标 = require("GGE.坐标")(多开数据[self.当前].__战斗主控.战斗单位[目标].显示xy.x, 多开数据[self.当前].__战斗主控.战斗单位[目标].显示xy.y)
	self.抓捕xy = require("GGE.坐标")(self.显示xy.x, self.显示xy.y)
	self.抓捕开关 = true
	self.抓捕编号 = 目标
end



function 战斗单位:取消变相(dt, x, y)
	self.动画.动画["待战"]:取高亮()
	if self.动画.武器 ~= nil then
		self.动画.武器["待战"]:取高亮()
	end
end

function 战斗单位:取消隐身(dt, x, y)
	self.动画.动画["待战"]:置颜色(255, 255, 255)
	if self.动画.武器 ~= nil then
		self.动画.武器["待战"]:置颜色(255, 255, 255)
	end
end

function 战斗单位:设置提示(内容)
	-- self.战斗提示.开关 = true
	-- self.战斗提示.内容 = 内容
	-- self.战斗提示.停止时间 = os.time() + 2
end

function 战斗单位:结束同步(气血, 最大气血, 气血上限, 魔法, 最大魔法, 愤怒, 护盾, 战意,五行珠,人参果,骤雨,超级战意)
	if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
		if self.单位类型 == "角色" then
			if self.气血 ~= nil and 气血 ~= nil then
				self.气血 = 气血
				多开数据[当前 or self and self.当前].角色信息.气血 = 气血
			end
			if 最大气血 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.最大气血 = 最大气血
				self.最大气血 = 最大气血
			end
			if 气血上限 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.气血上限 = 气血上限
			end
			if 魔法 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.魔法 = 魔法
			end
			if 最大魔法 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.最大魔法 = 最大魔法
			end
			if 愤怒 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.愤怒 = 愤怒
			end
			多开数据[self.当前].__UI界面.界面层.右上角:重置人物()
		elseif self.单位类型 == "bb" then
			if self.气血 ~= nil and 气血 ~= nil then
				self.气血 = 气血
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.气血 = 气血
			end
			if 最大气血 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.最大气血 = 最大气血
				self.最大气血 = 最大气血
			end
			if 魔法 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.魔法 = 魔法
			end
			if 最大魔法 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.最大魔法 = 最大魔法
			end
			多开数据[self.当前].__UI界面.界面层.右上角:重置召唤兽()
		end
	end
	if 护盾 ~= nil then
		self.护盾 = 护盾
	end
	if 战意 ~= nil then
		self.战意 = 战意
	end
	if 超级战意 ~= nil then
		self.超级战意 = 超级战意
		-- print(self.超级战意)
	end
	if 五行珠 ~= nil then
		self.五行珠 = 五行珠
	end
	if 人参果 ~= nil then
		self.人参果 = 人参果
	end
	if 骤雨 ~= nil then
		self.骤雨 = 骤雨
	end
end

function 战斗单位:魔法更新(魔法)
	if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
		if self.单位类型 == "角色" then
			多开数据[当前 or self and self.当前].角色信息.魔法 = 魔法
		elseif self.单位类型 == "bb" then
			多开数据[当前 or self and self.当前].角色信息.参战宝宝.魔法 = 魔法
		end
	end
	self.魔法 = 魔法
end

function 战斗单位:愤怒更新(愤怒)
	if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
		if self.单位类型 == "角色" then
			if 愤怒 ~= nil then
				多开数据[当前 or self and self.当前].角色信息.愤怒 = 愤怒
			end
		end
	end
	self.愤怒 = 愤怒
end

function 战斗单位:战意更新(战意)
	self.战意 = 战意
end

function 战斗单位:超级战意更新(超级战意)
	self.超级战意 = 超级战意
end
function 战斗单位:骤雨更新(骤雨)
	self.骤雨 = 骤雨
end

function 战斗单位:五行珠更新(五行珠)
	self.五行珠 = 五行珠
end

function 战斗单位:人参果更新(人参果)
	self.人参果 = 人参果
end

function 战斗单位:护盾更新(护盾)
	self.护盾 = 护盾
end

function 战斗单位:同步伤势(气血,气血上限,最大气血)
	if self.单位id == 多开数据[self.当前].角色信息.id then
		if self.气血上限 ~= nil and 气血上限 ~= nil then
			self.气血上限 = 气血上限
			多开数据[self.当前].角色信息.气血上限=气血上限
		end
	end
end

function 战斗单位:同步气血(气血,气血上限,最大气血)
	if self.单位类型 == "角色" then
		if self.气血 ~= nil and 气血 ~= nil then
			self.气血 = 气血
			if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
				多开数据[当前 or self and self.当前].角色信息.气血=气血
				多开数据[self.当前].__UI界面.界面层.右上角:重置人物()
			end
		end 
		if self.气血上限 ~= nil and 气血上限 ~= nil then
			self.气血上限 = 气血上限
			if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
				多开数据[当前 or self and self.当前].角色信息.气血上限=气血上限
				多开数据[self.当前].__UI界面.界面层.右上角:重置人物()
			end
		end
	elseif self.单位类型 == "bb" then
		if self.气血 ~= nil and 气血 ~= nil then
			self.气血 = 气血
			if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.气血=气血
				多开数据[self.当前].__UI界面.界面层.右上角:重置召唤兽()
			end
		end

	end
end

function 战斗单位:设置掉血(数额, 类型)
	local 护盾消耗 = 0
	if 数额 == nil then 数额 = 1 end
	数额 = math.floor(数额)
	if 类型==1 or 类型==3 or 类型==3.5 or 类型==4 then
		if self.护盾 ~= 0 then
			if self.护盾 >= 数额 then
				护盾消耗 = 数额
				数额 = 0
				self.护盾 = self.护盾 - 数额
				self.伤害数额 = ""..数额.."("..护盾消耗..")"
			else
				数额= 数额 - self.护盾
				护盾消耗 = self.护盾
				self.伤害数额 = ""..数额.."("..护盾消耗..")"
				self.护盾 = 0
			end
		else
			self.伤害数额 = 数额
		end
	else
		self.伤害数额 = 数额
		if self.气血+数额>self.最大气血 then
		    self.伤害数额 = self.最大气血-self.气血
		end
		if self.伤害数额<=0 then
		    return
		end
	end
	self.伤害总数 = string.len(tostring(self.伤害数额))
	local 临时序列 = {}
	self.弹跳次数 = 18
	self.弹跳间隔 = 2
	self.伤害类型 = 类型
	self.掉血开关 = true
	self.加血顺序 = 0
	if 类型 == 1 or 类型 == 3 or 类型 == 4 then
		self.气血 = self.气血 - 数额
		if self.气血 < 0 then
			self.气血 = 0
		end
		if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
			if self.单位类型 == "角色" then
				多开数据[当前 or self and self.当前].角色信息.气血 = math.floor(self.气血)
				多开数据[当前 or self and self.当前].角色信息.最大气血 = math.floor(self.最大气血)
				多开数据[当前 or self and self.当前].角色信息.气血上限 = math.floor(self.气血上限)
				临时愤怒 = math.floor(数额 / 多开数据[当前 or self and self.当前].角色信息.最大气血 * 0.5 * 100)
				多开数据[当前 or self and self.当前].角色信息.愤怒 = 多开数据[当前 or self and self.当前].角色信息.愤怒 + 临时愤怒
				if 多开数据[当前 or self and self.当前].角色信息.愤怒 > 150 then 多开数据[当前 or self and self.当前].角色信息.愤怒 = 150 end
				多开数据[self.当前].__UI界面.界面层.右上角:重置人物()
			elseif self.单位类型 == "bb" then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.气血 = self.气血
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.最大气血 = self.最大气血
				多开数据[self.当前].__UI界面.界面层.右上角:重置召唤兽()
			end
		end
	else
		self.气血 = self.气血 + 数额
		if self.气血 > self.最大气血 then self.气血 = self.最大气血 end
		if self.气血上限 and self.气血上限 > self.最大气血 then
			self.气血上限 = self.最大气血
		end
		if self.单位id == 多开数据[当前 or self and self.当前].角色信息.id then
			if self.单位类型 == "角色" then
				多开数据[当前 or self and self.当前].角色信息.气血 = self.气血
				多开数据[当前 or self and self.当前].角色信息.最大气血 = self.最大气血
				多开数据[当前 or self and self.当前].角色信息.气血上限 = math.floor(self.气血上限)
				多开数据[self.当前].__UI界面.界面层.右上角:重置人物()
			elseif self.单位类型 == "bb" then
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.气血 = self.气血
				多开数据[当前 or self and self.当前].角色信息.参战宝宝.最大气血 = self.最大气血
				多开数据[self.当前].__UI界面.界面层.右上角:重置召唤兽()
			end
		end
	end
	临时序列.时间 = self.伤害总数 * 40
	if #self.伤害序列 ~= 0 then
		临时序列.进入 = math.floor(self.伤害序列[#self.伤害序列].时间 / 2)
	else
		临时序列.进入 = 0
	end
	临时序列.顺序 = 0
	for n = 1, self.伤害总数 do
		临时序列[n] = {}
		临时序列[n].数字 = string.sub(self.伤害数额, n, n)
		if 临时序列[n].数字 == "(" then
			临时序列[n].数字 = 10
		elseif 临时序列[n].数字 == ")" then
			临时序列[n].数字 = 11
		end
		临时序列[n].高度 = 0
		临时序列[n].x = self.显示xy.x - self.伤害总数 * 2 - self.伤害总数 * 1.5
		临时序列[n].y = self.显示xy.y
	end
	self.血条栏:置区域(0, 0, math.floor(self.气血 / self.最大气血 * 36), 4)
	if self.气血上限 then
		self.血条上限栏:置区域(0, 0, (self.气血上限 / self.最大气血) * 36, 4)
	end
	table.insert(self.伤害序列, 临时序列)
	self.弹跳顺序 = 1
end

function 战斗单位:检查点(x, y)
	return self.动画:检查点(x, y, self.动作)
end

function 战斗单位:更新(dt)
	self.显示表 = {}
	local _加入显示 = ggf.insert(self.显示表)
	if self.移动开关 then self:移动事件() end
	if self.击退开关 then self:击退处理() end
	if self.击飞开关 then self:击飞处理() end
	if self.返回开关 then self:返回事件() end
	if self.躲避开关 then self:躲避事件() end
	if self.倒地开关 then self:倒地处理() end
	if self.抓捕开关 then
		if self.捕捉暂停 ~= nil and os.time() - self.捕捉暂停 >= 1 then
			self.捕捉暂停 = nil
			self.抓捕动画:置方向(1)
			-- self.抓捕开关=false
			if self.抓捕成功 then
				多开数据[self.当前].__战斗主控.战斗单位[self.抓捕编号]:设置抓捕路径(require("GGE.坐标")(self.显示xy.x, self.显示xy.y), self.抓捕成功)
			end
		end
		self.抓捕动画:更新(dt)
		if self.抓捕流程 == 1 then
			self.抓捕xy:移动(6, self.抓捕目标.x, self.抓捕目标.y)
			if self.抓捕xy:取距离(self.抓捕目标.x, self.抓捕目标.y) <= 40 then
				self.抓捕流程 = 2
				self.捕捉暂停 = os.time()
			end
		elseif self.抓捕流程 == 2 and self.捕捉暂停 == nil then
			self.抓捕xy:移动(6, self.显示xy.x, self.显示xy.y)
			if self.抓捕xy:取距离(self.显示xy.x, self.显示xy.y) <= 10 then
				self.抓捕动画 = nil
				self.抓捕开关 = false
			end
		end
	end
	if self.抓捕移动 ~= nil then
		self.显示xy:移动(6, self.抓捕移动.x, self.抓捕移动.y)
		if self.抓捕移动:取距离(self.显示xy.x, self.显示xy.y) <= 30 then
			self.是否显示 = false
			self.显示xy.x, self.显示xy.y = 1500, 1500
			self.抓捕移动 = nil
		end
	end

	if self.吸星大法移动 ~= nil then
		self.显示xy:移动(6, self.吸星大法移动.x, self.吸星大法移动.y)
		if self.吸星大法移动:取距离(self.显示xy.x, self.显示xy.y) <= 30 then
			self.吸星大法移动 = nil
			self:换方向(5)
		end
	end

	if self.吸星大法返回~=nil then
		self.显示xy:移动(6, self.吸星大法返回.x, self.吸星大法返回.y)
		if self.吸星大法返回:取距离(self.显示xy.x, self.显示xy.y)<=10 then
			self.吸星大法返回=nil
			self:换方向(self.初始方向)
		end
	end

	if self.飞镖开关 then
		self.飞镖xy:移动(10, self.显示xy.x, self.显示xy.y)
		if self.飞镖xy:取距离(self.显示xy.x, self.显示xy.y) <= 20 then
			self:设置掉血(self.飞镖xy.伤害, 1)
			self:换动作("挨打", nil, true)
			self:开启击退(self.飞镖xy.死亡)
			self.飞镖开关 = nil
			--self.飞镖动画:释放()
			self.飞镖动画 = nil
		end
	end
	if self.弓弩开关 then
		self.弓弩xy:移动(20, self.显示xy.x, self.显示xy.y)
		if self.弓弩xy:取距离(self.显示xy.x, self.显示xy.y) <= 20 then
			self.弓弩开关 = nil
			self.弓弩动画 = nil
		end
	end
	if self.状态特效["修罗隐身"] or self.状态特效["分身术"] or self.状态特效["楚楚可怜"] then
		self.动画.动画["待战"]:置颜色(150, 240, 240)
		if self.动画.武器 ~= nil then
			self.动画.武器["待战"]:置颜色(150, 240, 240)
		end
	end
	if self.状态特效["金刚护法"] ~= nil and self.状态特效["修罗隐身"] == nil and self.状态特效["分身术"] == nil then
		self.色相变身 = self.色相变身 + 1
		if self.色相变身 >= 30 then
			self.动画.动画["待战"]:取高亮()
			if self.动画.武器 ~= nil then
				self.动画.武器["待战"]:取高亮()
			end
			if self.色相变身 >= 60 then
				self.色相变身 = 0
			end
		else
			self.动画.动画["待战"]:置高亮(-10855936)
			if self.动画.武器 ~= nil then
				self.动画.武器["待战"]:置高亮(-10855936)
			end
		end
	end
	-- if self.状态特效["超级强力"] ~= nil then
	-- 	self.动画:置方向(math.random(0,7),self.动作) 
	-- end
	if self.动作复原 then
		if not self.动画:是否播放(self.动作) then
			if self.动作 == "攻击" then
				--self.动画:置帧率("攻击",0.1)
			end
			self:换动作("待战")
		end
	end
	if self.飞镖开关 then
		self.飞镖动画:更新(dt)
	end
	if self.弓弩开关 then
		self.弓弩动画:更新(dt)
	end
	if self.逃跑开关 then
		if not self.逃跑特效 then
			self.动作 = "返回"
			self.逃跑特效 = 多开数据[self.当前].__主控:载入特效("逃跑", self:取txz("逃跑"))
			self.逃跑特效.cp, self.逃跑特效.py = 1, { 0, 0 }
		end
		self.逃跑特效:更新(dt)
		_加入显示(self.逃跑特效)
	end
	if self.战意 then
		if self.战意 == 1 then
			if not self.战意特效[1] then
				self.战意特效[1] = 多开数据[self.当前].__主控:载入特效("状态_战意1", 1):置循环(true)
				self.战意特效[1].cp, self.战意特效[1].py = 1, { 0, 0 }
			end
			self.战意特效[1]:更新(dt)
			_加入显示(self.战意特效[1])
		elseif self.战意 == 2 then
			if not self.战意特效[2] then
				self.战意特效[2] = 多开数据[self.当前].__主控:载入特效("状态_战意2", 1):置循环(true)
				self.战意特效[2].cp, self.战意特效[2].py = 1, { 0, 0 }
			end
			self.战意特效[2]:更新(dt)
			_加入显示(self.战意特效[2])
		elseif self.战意 >= 3 then
			if not self.战意特效[3] then
				self.战意特效[3] = 多开数据[self.当前].__主控:载入特效("状态_战意3", 1):置循环(true)
				self.战意特效[3].cp, self.战意特效[3].py = 1, { 0, 0 }
			end
			self.战意特效[3]:更新(dt)
			_加入显示(self.战意特效[3])
		end
	end
	if self.动作 == "待战" or self.动作 == "倒地" or self.动作 == "挨打" then
		if self.状态特效.疯狂 or self.状态特效.反间之计 or self.状态特效.发瘟匣 or self.状态特效.失心钹 or self.状态特效.奇门五行令 or self.开始抖动 then
			if self.抖动数据.开关 == false then
				self.抖动数据.开关 = true
				self.抖动数据.进程 = 1
				self.抖动数据.x, self.抖动数据.y = -1, -1
			else
				self.抖动数据.进程 = self.抖动数据.进程 + 1
				if self.抖动数据.进程 <= 5 then
					self.抖动数据.x, self.抖动数据.y = self.抖动数据.进程 - self.抖动数据.进程 * 2, self.抖动数据.进程 - self.抖动数据.进程 * 2
				else
					self.抖动数据.x, self.抖动数据.y = self.抖动数据.x + 1, self.抖动数据.y + 1
					if self.抖动数据.进程 >= 12 then
						self.抖动数据.进程 = 0
					end
				end
			end
		elseif self.抖动数据.开关 then
			self.抖动数据.进程 = 0
			self.抖动数据.x, self.抖动数据.y = 0, 0
			self.抖动数据.开关 = false
		end
	end
	for i, v in pairs(self.状态特效) do
		if v and v.动画 then
			if type(v.动画) == "table" and v.动画[1] and v.动画[2] then
				for n = 1, #v.动画 do
					if self:状态是否显示(i) then
						v.动画[n]:更新(dt)
						_加入显示(v.动画[n])
					end
				end
			else
				if self:状态是否显示(i) then
					v.动画:更新(dt)
					_加入显示(v.动画)
				end
			end
		end
	end
	for i, v in pairs(self.攻击特效) do
		v:更新(dt)
		_加入显示(v)
		if not v:是否播放() then
			table.remove(self.攻击特效, i)
		end
	end
	for i, v in pairs(self.法术特效) do
		if v then
			if v.加速 == nil then
				v:更新(dt)
			else
				v:更新(v.加速)
			end
			if v.结束时间 ~= nil then
				v.结束时间 = v.结束时间 - 1
				if v.结束时间 < 20 then
					v.py[2] = v.py[2] - 3
				end
				_加入显示(v)
				if v.结束时间 == 0 and not v:是否播放() then
					table.remove(self.法术特效, i)
					if 多开数据[self.当前].__战斗主控.掉血流程 ~= nil and #self.法术特效 == 多开数据[self.当前].__战斗主控.掉血流程 then 多开数据[self.当前].__战斗主控.掉血流程 = nil end
				end
			else
				_加入显示(v)
				if not v:是否播放() then
					table.remove(self.法术特效, i)
				end
				if 多开数据[self.当前].__战斗主控.掉血流程 ~= nil and #self.法术特效 == i and v:取当前帧() == math.floor(v:取帧数() / 1.5) then 多开数据[self.当前].__战斗主控.掉血流程 = nil end
			end
		end
	end
	self.动画:更新(dt, self.动作)
	_加入显示(self.动画)
	table.sort(self.显示表, 排序)
end

function 战斗单位:显示(x, y)
	if self.是否显示 == false then return end
	self.名称精灵:显示(self.显示xy.x + self.抖动数据.x + self.名称py, self.显示xy.y + self.抖动数据.y + 10)
	if self.敌我 == 1 then
		多开数据[self.当前].__战斗主控.血条背景:显示(self.显示xy.x + self.抖动数据.x - 23, self.显示xy.y + self.抖动数据.y - self.高度 + 5)
		if self.气血上限 and self.气血上限 < self.最大气血 then
			self.血条上限栏:显示(self.显示xy.x + self.抖动数据.x - 22, self.显示xy.y + self.抖动数据.y - self.高度 + 6)
		end
		self.血条栏:显示(self.显示xy.x + self.抖动数据.x - 22, self.显示xy.y + self.抖动数据.y - self.高度 + 6)
	end
	if (self.浮空高度 or 0) > 0 and self.死亡参数 == nil and self.逃跑开关 ~= true then
        if self.动作 ~= "挨打" then
            self.动作 = "挨打"

            self:换动作("挨打")
        end
        self.停止更新 = true
        self.浮空动画:更新(0.03)
        self.浮空动画:显示(self.显示xy.x + self.抖动数据.x, self.显示xy.y + self.抖动数据.y + 20)
    end
	if not self.躲避开关 then
        if self.浮空开关 == false and self.浮空高度 > 0 then
            self.浮空下降 = self.浮空下降 + 1
            local jg = 2

            if self.浮空下降 > 0 and self.浮空下降 % jg == 0 then
                local jf = self.浮空下降 + 0.5 * self.浮空下降 * self.浮空下降 / (jg * jg)

                if self.浮空高度 < jf then
                    jf = self.浮空高度
                end

                self.浮空高度 = self.浮空高度 - jf
            end

            if self.浮空高度 == 0 and self.死亡参数 == nil and self.逃跑开关 ~= true then
                self.停止更新 = false
                self.动作 = "待战"
            end
        end
        if not self.特殊浮空开关 and self.特殊浮空高度 > 0 then
            self.特殊浮空高度 = 0
        end
        if not self.临时隐藏 then
            if self.攻击对象 ~= nil and 多开数据[self.当前].__战斗主控.战斗单位[self.攻击对象].浮空高度 ~= nil then
                self.动画:显示(self.显示xy.x + self.抖动数据.x, self.显示xy.y + self.抖动数据.y - (多开数据[self.当前].__战斗主控.战斗单位[self.攻击对象].浮空高度 or 0) , self.动作)
            elseif self.行动对象 and 多开数据[self.当前].__战斗主控.战斗单位[self.行动对象].特殊浮空高度 ~= nil then
                self.动画:显示(self.显示xy.x + self.抖动数据.x, self.显示xy.y + self.抖动数据.y - (多开数据[self.当前].__战斗主控.战斗单位[self.行动对象].特殊浮空高度 or 0) , self.动作)
            else
                self.动画:显示(self.显示xy.x + self.抖动数据.x, self.显示xy.y + self.抖动数据.y - (self.浮空高度 or 0) , self.动作)
            end
        end
    end

	if self.特技内容开关 then
		self:特技文本显示()
	end
	for i = 1, #self.显示表 do
		self.显示表[i]:显示(self.显示xy.x + self.抖动数据.x + self.显示表[i].py[1], self.显示xy.y + self.抖动数据.y + self.显示表[i].py[2],
			self.动作)
	end
	if self.标记 then
		名字16:显示(self.显示xy.x + self.抖动数据.x + self.名称py, self.显示xy.y + self.抖动数据.y - 20, self.标记)
	end
	if self.抓捕开关 then
		self.抓捕动画:显示(self.抓捕xy.x, self.抓捕xy.y)
		多开数据[self.当前].__主显.影子:显示(self.抓捕xy.x, self.抓捕xy.y)
	end
	if self.飞镖开关 then
		self.飞镖动画:显示(self.飞镖xy.x, self.飞镖xy.y)
	end
	if self.弓弩开关 then
		self.弓弩动画:显示(self.弓弩xy.x, self.弓弩xy.y)
	end
	if self.丸子特效 and self.丸子time.时间 - os.time() > 0 then
		self.丸子特效:显示(self.显示xy.x + self.抖动数据.x - 22, self.显示xy.y + self.抖动数据.y - self.高度-5)
	end
end

function 战斗单位:单位血条显示()
	多开数据[self.当前].__战斗主控.血条背景:显示(self.显示xy.x + self.抖动数据.x - 23, self.显示xy.y + self.抖动数据.y - self.高度 + 5)
	if self.气血上限 and self.气血上限 < self.最大气血 then
		self.血条上限栏:显示(self.显示xy.x + self.抖动数据.x - 22, self.显示xy.y + self.抖动数据.y - self.高度 + 6)
	end
	self.血条栏:显示(self.显示xy.x + self.抖动数据.x - 22, self.显示xy.y + self.抖动数据.y - self.高度 + 6)
end

function 战斗单位:特技文本显示()
	self.关闭计次 = self.关闭计次 + 1
	for n = 1, self.特技总数 do
		if n == self.特技顺序 then
			self.特技序列[n].高度 = self.特技序列[n].高度 + self.特技间隔
			if (self.特技序列[n].高度 >= self.特技次数) then
				self.特技顺序 = self.特技顺序 + 1
			end
		elseif self.特技序列[n].高度 > 0 then
			self.特技序列[n].高度 = self.特技序列[n].高度 - 1
		end
		字体18:取图像(self.特技序列[n].文本):显示(self.特技序列[n].x - 30 + n * 16, self.特技序列[n].y - self.高度 - 30 - self.特技序列[n].高度)
	end
	if self.关闭计次 >= 50 then self.特技内容开关 = false end
end

function 战斗单位:加血显示()
	for n = 1, #self.伤害序列 do
		for i = 1, #self.伤害序列[n] do
			if self.伤害序列[n].进入 ~= 0 then
				self.伤害序列[n].进入 = self.伤害序列[n].进入 - 1
			else
				self.伤害序列[n].顺序 = self.伤害序列[n].顺序 + 1
				if n == self.弹跳顺序 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 + self.弹跳间隔
					if (self.伤害序列[n][i].高度 >= self.弹跳次数) then
						self.弹跳顺序 = self.弹跳顺序 + 1
					end
				elseif self.伤害序列[n][i].高度 > 0 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 - 1
				end
				if (self.敌我 == 2) then
					self.回复图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
						math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
				else
					self.回复图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
						math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
				end
			end
		end
	end
	for n = 1, #self.伤害序列 do
		if self.伤害序列[n] and self.伤害序列[n].顺序 >= self.伤害序列[n].时间 then
			table.remove(self.伤害序列, n)
			break
		end
	end
	if #self.伤害序列 == 0 then
		self.掉血开关 = false
		self.伤害序列 = {}
	end
end

function 战斗单位:掉血显示()
	for n = 1, #self.伤害序列 do
		for i = 1, #self.伤害序列[n] do
			if self.伤害序列[n].进入 ~= 0 then
				self.伤害序列[n].进入 = self.伤害序列[n].进入 - 1
			else
				self.伤害序列[n].顺序 = self.伤害序列[n].顺序 + 1
				if n == self.弹跳顺序 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 + self.弹跳间隔
					if (self.伤害序列[n][i].高度 >= self.弹跳次数) then
						self.弹跳顺序 = self.弹跳顺序 + 1
					end
				elseif self.伤害序列[n][i].高度 > 0 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 - 1
				end
				if (self.敌我 == 2) then
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then return 0 end
					self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
						math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
				else
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then return 0 end
					if self.伤害序列[n][i].数字 == nil then self.伤害序列[n][i].数字 = 0 end
					self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 10 + i * 12),
						math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
				end
			end
		end
	end
	for n = 1, #self.伤害序列 do
		if self.伤害序列[n].顺序 >= self.伤害序列[n].时间 then
			table.remove(self.伤害序列, n)
			break
		end
	end
	if #self.伤害序列 == 0 then
		self.掉血开关 = false
		self.伤害序列 = {}
	end
end

function 战斗单位:暴击显示()
	for n = 1, #self.伤害序列 do
		for i = 1, #self.伤害序列[n] do
			if self.伤害序列[n].进入 ~= 0 then
				self.伤害序列[n].进入 = self.伤害序列[n].进入 - 1
			else
				self.伤害序列[n].顺序 = self.伤害序列[n].顺序 + 1
				if n == self.弹跳顺序 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 + self.弹跳间隔
					if (self.伤害序列[n][i].高度 >= self.弹跳次数) then
						self.弹跳顺序 = self.弹跳顺序 + 1
					end
				elseif self.伤害序列[n][i].高度 > 0 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 - 1
				end
				if (self.敌我 == 2) then
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then
						return 0
					end
					if self.伤害序列[n].顺序 < self.伤害序列[n].时间 / 2 then
						self.暴击图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					else
						self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					end
				else
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then
						return 0
					end
					if self.伤害序列[n][i].数字 == nil then
						self.伤害序列[n][i].数字 = 0
					end
					if self.伤害序列[n].顺序 < self.伤害序列[n].时间 / 2 then
						self.暴击图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 10 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					else
						self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 10 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					end
				end
			end
		end
	end
	for n = 1, #self.伤害序列 do
		if self.伤害序列[n].顺序 >= self.伤害序列[n].时间 then
			table.remove(self.伤害序列, n)
			break
		end
	end
	if #self.伤害序列 == 0 then
		self.掉血开关 = false
		self.伤害序列 = {}
	end
end

function 战斗单位:法术暴击显示()
	for n = 1, #self.伤害序列 do
		for i = 1, #self.伤害序列[n] do
			if self.伤害序列[n].进入 ~= 0 then
				self.伤害序列[n].进入 = self.伤害序列[n].进入 - 1
			else
				self.伤害序列[n].顺序 = self.伤害序列[n].顺序 + 1
				if n == self.弹跳顺序 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 + self.弹跳间隔
					if (self.伤害序列[n][i].高度 >= self.弹跳次数) then
						self.弹跳顺序 = self.弹跳顺序 + 1
					end
				elseif self.伤害序列[n][i].高度 > 0 then
					self.伤害序列[n][i].高度 = self.伤害序列[n][i].高度 - 1
				end
				if (self.敌我 == 2) then
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then
						return 0
					end
					if self.伤害序列[n].顺序 < self.伤害序列[n].时间 / 2 then
						self.法术暴击图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					else
						self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 20 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					end
				else
					if self.伤害序列[n][i] == nil or self.伤害序列[n][i].数字 == nil then
						return 0
					end
					if self.伤害序列[n][i].数字 == nil then
						self.伤害序列[n][i].数字 = 0
					end
					if self.伤害序列[n].顺序 < self.伤害序列[n].时间 / 2 then
						self.法术暴击图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 10 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					else
						self.伤害图片[self.伤害序列[n][i].数字 + 1]:显示(math.floor(self.伤害序列[n][i].x - 10 + i * 12),
							math.floor(self.伤害序列[n][i].y - 30 - self.伤害序列[n][i].高度 - ((#self.伤害序列 - n) * 20)))
					end
				end
			end
		end
	end
	if #self.伤害序列 > 0 then
		for n = 1, #self.伤害序列 do
			if  n > #self.伤害序列 then
				break
			end
			if self.伤害序列[n].顺序 >= self.伤害序列[n].时间 then
				table.remove(self.伤害序列, n)
				n=n-1
				if #self.伤害序列 == 0 then
					break
				end
			end
		end
	end
	if #self.伤害序列 == 0 then
		self.掉血开关 = false
		self.伤害序列 = {}
	end
end
function 战斗单位:浮空处理()
    if self.浮空开关 == true then
        return
    end

    if self.死亡参数 == nil and self.逃跑开关 ~= true then
        self.浮空开关 = true
        self.浮空高度 = 50
        self.动作 = "挨打"
        self.停止更新 = true
    end
end

function 战斗单位:浮空处理1()
    self.特殊浮空开关 = true
    self.特殊浮空高度 = 50
end

function 战斗单位:取消浮空(下降)
    if self.浮空开关 ~= true then
        return
    end
    self.浮空开关 = false
    self.浮空下降 = 下降 or 0
    self.浮空下降 = qz(self.浮空下降 * 0.6)
end
return 战斗单位
